home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / xml / dom / xmlbuilder.pyc (.txt) < prev   
Python Compiled Bytecode  |  2014-12-31  |  15KB  |  415 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. """Implementation of the DOM Level 3 'LS-Load' feature."""
  5. import copy
  6. import xml.dom as xml
  7. from xml.dom.NodeFilter import NodeFilter
  8. __all__ = [
  9.     'DOMBuilder',
  10.     'DOMEntityResolver',
  11.     'DOMInputSource']
  12.  
  13. class Options:
  14.     '''Features object that has variables set for each DOMBuilder feature.
  15.  
  16.     The DOMBuilder class uses an instance of this class to pass settings to
  17.     the ExpatBuilder class.
  18.     '''
  19.     namespaces = 1
  20.     namespace_declarations = True
  21.     validation = False
  22.     external_parameter_entities = True
  23.     external_general_entities = True
  24.     external_dtd_subset = True
  25.     validate_if_schema = False
  26.     validate = False
  27.     datatype_normalization = False
  28.     create_entity_ref_nodes = True
  29.     entities = True
  30.     whitespace_in_element_content = True
  31.     cdata_sections = True
  32.     comments = True
  33.     charset_overrides_xml_encoding = True
  34.     infoset = False
  35.     supported_mediatypes_only = False
  36.     errorHandler = None
  37.     filter = None
  38.  
  39.  
  40. class DOMBuilder:
  41.     entityResolver = None
  42.     errorHandler = None
  43.     filter = None
  44.     ACTION_REPLACE = 1
  45.     ACTION_APPEND_AS_CHILDREN = 2
  46.     ACTION_INSERT_AFTER = 3
  47.     ACTION_INSERT_BEFORE = 4
  48.     _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)
  49.     
  50.     def __init__(self):
  51.         self._options = Options()
  52.  
  53.     
  54.     def _get_entityResolver(self):
  55.         return self.entityResolver
  56.  
  57.     
  58.     def _set_entityResolver(self, entityResolver):
  59.         self.entityResolver = entityResolver
  60.  
  61.     
  62.     def _get_errorHandler(self):
  63.         return self.errorHandler
  64.  
  65.     
  66.     def _set_errorHandler(self, errorHandler):
  67.         self.errorHandler = errorHandler
  68.  
  69.     
  70.     def _get_filter(self):
  71.         return self.filter
  72.  
  73.     
  74.     def _set_filter(self, filter):
  75.         self.filter = filter
  76.  
  77.     
  78.     def setFeature(self, name, state):
  79.         if self.supportsFeature(name):
  80.             if not state or 1:
  81.                 pass
  82.             state = 0
  83.             
  84.             try:
  85.                 settings = self._settings[(_name_xform(name), state)]
  86.             except KeyError:
  87.                 raise xml.dom.NotSupportedErr('unsupported feature: %r' % (name,))
  88.  
  89.             for name, value in settings:
  90.                 setattr(self._options, name, value)
  91.             
  92.         else:
  93.             raise xml.dom.NotFoundErr('unknown feature: ' + repr(name))
  94.  
  95.     
  96.     def supportsFeature(self, name):
  97.         return hasattr(self._options, _name_xform(name))
  98.  
  99.     
  100.     def canSetFeature(self, name, state):
  101.         if not state or 1:
  102.             pass
  103.         key = (_name_xform(name), 0)
  104.         return key in self._settings
  105.  
  106.     _settings = {
  107.         ('namespace_declarations', 0): [
  108.             ('namespace_declarations', 0)],
  109.         ('namespace_declarations', 1): [
  110.             ('namespace_declarations', 1)],
  111.         ('validation', 0): [
  112.             ('validation', 0)],
  113.         ('external_general_entities', 0): [
  114.             ('external_general_entities', 0)],
  115.         ('external_general_entities', 1): [
  116.             ('external_general_entities', 1)],
  117.         ('external_parameter_entities', 0): [
  118.             ('external_parameter_entities', 0)],
  119.         ('external_parameter_entities', 1): [
  120.             ('external_parameter_entities', 1)],
  121.         ('validate_if_schema', 0): [
  122.             ('validate_if_schema', 0)],
  123.         ('create_entity_ref_nodes', 0): [
  124.             ('create_entity_ref_nodes', 0)],
  125.         ('create_entity_ref_nodes', 1): [
  126.             ('create_entity_ref_nodes', 1)],
  127.         ('entities', 0): [
  128.             ('create_entity_ref_nodes', 0),
  129.             ('entities', 0)],
  130.         ('entities', 1): [
  131.             ('entities', 1)],
  132.         ('whitespace_in_element_content', 0): [
  133.             ('whitespace_in_element_content', 0)],
  134.         ('whitespace_in_element_content', 1): [
  135.             ('whitespace_in_element_content', 1)],
  136.         ('cdata_sections', 0): [
  137.             ('cdata_sections', 0)],
  138.         ('cdata_sections', 1): [
  139.             ('cdata_sections', 1)],
  140.         ('comments', 0): [
  141.             ('comments', 0)],
  142.         ('comments', 1): [
  143.             ('comments', 1)],
  144.         ('charset_overrides_xml_encoding', 0): [
  145.             ('charset_overrides_xml_encoding', 0)],
  146.         ('charset_overrides_xml_encoding', 1): [
  147.             ('charset_overrides_xml_encoding', 1)],
  148.         ('infoset', 0): [],
  149.         ('infoset', 1): [
  150.             ('namespace_declarations', 0),
  151.             ('validate_if_schema', 0),
  152.             ('create_entity_ref_nodes', 0),
  153.             ('entities', 0),
  154.             ('cdata_sections', 0),
  155.             ('datatype_normalization', 1),
  156.             ('whitespace_in_element_content', 1),
  157.             ('comments', 1),
  158.             ('charset_overrides_xml_encoding', 1)],
  159.         ('supported_mediatypes_only', 0): [
  160.             ('supported_mediatypes_only', 0)],
  161.         ('namespaces', 0): [
  162.             ('namespaces', 0)],
  163.         ('namespaces', 1): [
  164.             ('namespaces', 1)] }
  165.     
  166.     def getFeature(self, name):
  167.         xname = _name_xform(name)
  168.         
  169.         try:
  170.             return getattr(self._options, xname)
  171.         except AttributeError:
  172.             if name == 'infoset':
  173.                 options = self._options
  174.                 if options.datatype_normalization and options.whitespace_in_element_content and options.comments and options.charset_overrides_xml_encoding:
  175.                     if not options.namespace_declarations and options.validate_if_schema and options.create_entity_ref_nodes and options.entities:
  176.                         pass
  177.                 return not (options.cdata_sections)
  178.             raise None.dom.NotFoundErr('feature %s not known' % repr(name))
  179.  
  180.  
  181.     
  182.     def parseURI(self, uri):
  183.         if self.entityResolver:
  184.             input = self.entityResolver.resolveEntity(None, uri)
  185.         else:
  186.             input = DOMEntityResolver().resolveEntity(None, uri)
  187.         return self.parse(input)
  188.  
  189.     
  190.     def parse(self, input):
  191.         options = copy.copy(self._options)
  192.         options.filter = self.filter
  193.         options.errorHandler = self.errorHandler
  194.         fp = input.byteStream
  195.         if fp is None and options.systemId:
  196.             import urllib2 as urllib2
  197.             fp = urllib2.urlopen(input.systemId)
  198.         return self._parse_bytestream(fp, options)
  199.  
  200.     
  201.     def parseWithContext(self, input, cnode, action):
  202.         if action not in self._legal_actions:
  203.             raise ValueError('not a legal action')
  204.         raise NotImplementedError("Haven't written this yet...")
  205.  
  206.     
  207.     def _parse_bytestream(self, stream, options):
  208.         import xml.dom.expatbuilder as xml
  209.         builder = xml.dom.expatbuilder.makeBuilder(options)
  210.         return builder.parseFile(stream)
  211.  
  212.  
  213.  
  214. def _name_xform(name):
  215.     return name.lower().replace('-', '_')
  216.  
  217.  
  218. class DOMEntityResolver(object):
  219.     __slots__ = ('_opener',)
  220.     
  221.     def resolveEntity(self, publicId, systemId):
  222.         if not systemId is not None:
  223.             raise AssertionError
  224.         source = None()
  225.         source.publicId = publicId
  226.         source.systemId = systemId
  227.         source.byteStream = self._get_opener().open(systemId)
  228.         source.encoding = self._guess_media_encoding(source)
  229.         import posixpath as posixpath
  230.         import urlparse as urlparse
  231.         parts = urlparse.urlparse(systemId)
  232.         (scheme, netloc, path, params, query, fragment) = parts
  233.         if path and not path.endswith('/'):
  234.             path = posixpath.dirname(path) + '/'
  235.             parts = (scheme, netloc, path, params, query, fragment)
  236.             source.baseURI = urlparse.urlunparse(parts)
  237.         return source
  238.  
  239.     
  240.     def _get_opener(self):
  241.         
  242.         try:
  243.             return self._opener
  244.         except AttributeError:
  245.             self._opener = self._create_opener()
  246.             return self._opener
  247.  
  248.  
  249.     
  250.     def _create_opener(self):
  251.         import urllib2
  252.         return urllib2.build_opener()
  253.  
  254.     
  255.     def _guess_media_encoding(self, source):
  256.         info = source.byteStream.info()
  257.         if 'Content-Type' in info:
  258.             for param in info.getplist():
  259.                 if param.startswith('charset='):
  260.                     return param.split('=', 1)[1].lower()
  261.             
  262.  
  263.  
  264.  
  265. class DOMInputSource(object):
  266.     __slots__ = ('byteStream', 'characterStream', 'stringData', 'encoding', 'publicId', 'systemId', 'baseURI')
  267.     
  268.     def __init__(self):
  269.         self.byteStream = None
  270.         self.characterStream = None
  271.         self.stringData = None
  272.         self.encoding = None
  273.         self.publicId = None
  274.         self.systemId = None
  275.         self.baseURI = None
  276.  
  277.     
  278.     def _get_byteStream(self):
  279.         return self.byteStream
  280.  
  281.     
  282.     def _set_byteStream(self, byteStream):
  283.         self.byteStream = byteStream
  284.  
  285.     
  286.     def _get_characterStream(self):
  287.         return self.characterStream
  288.  
  289.     
  290.     def _set_characterStream(self, characterStream):
  291.         self.characterStream = characterStream
  292.  
  293.     
  294.     def _get_stringData(self):
  295.         return self.stringData
  296.  
  297.     
  298.     def _set_stringData(self, data):
  299.         self.stringData = data
  300.  
  301.     
  302.     def _get_encoding(self):
  303.         return self.encoding
  304.  
  305.     
  306.     def _set_encoding(self, encoding):
  307.         self.encoding = encoding
  308.  
  309.     
  310.     def _get_publicId(self):
  311.         return self.publicId
  312.  
  313.     
  314.     def _set_publicId(self, publicId):
  315.         self.publicId = publicId
  316.  
  317.     
  318.     def _get_systemId(self):
  319.         return self.systemId
  320.  
  321.     
  322.     def _set_systemId(self, systemId):
  323.         self.systemId = systemId
  324.  
  325.     
  326.     def _get_baseURI(self):
  327.         return self.baseURI
  328.  
  329.     
  330.     def _set_baseURI(self, uri):
  331.         self.baseURI = uri
  332.  
  333.  
  334.  
  335. class DOMBuilderFilter:
  336.     '''Element filter which can be used to tailor construction of
  337.     a DOM instance.
  338.     '''
  339.     FILTER_ACCEPT = 1
  340.     FILTER_REJECT = 2
  341.     FILTER_SKIP = 3
  342.     FILTER_INTERRUPT = 4
  343.     whatToShow = NodeFilter.SHOW_ALL
  344.     
  345.     def _get_whatToShow(self):
  346.         return self.whatToShow
  347.  
  348.     
  349.     def acceptNode(self, element):
  350.         return self.FILTER_ACCEPT
  351.  
  352.     
  353.     def startContainer(self, element):
  354.         return self.FILTER_ACCEPT
  355.  
  356.  
  357. del NodeFilter
  358.  
  359. class DocumentLS:
  360.     '''Mixin to create documents that conform to the load/save spec.'''
  361.     async = False
  362.     
  363.     def _get_async(self):
  364.         return False
  365.  
  366.     
  367.     def _set_async(self, async):
  368.         if async:
  369.             raise xml.dom.NotSupportedErr('asynchronous document loading is not supported')
  370.  
  371.     
  372.     def abort(self):
  373.         raise NotImplementedError("haven't figured out what this means yet")
  374.  
  375.     
  376.     def load(self, uri):
  377.         raise NotImplementedError("haven't written this yet")
  378.  
  379.     
  380.     def loadXML(self, source):
  381.         raise NotImplementedError("haven't written this yet")
  382.  
  383.     
  384.     def saveXML(self, snode):
  385.         if snode is None:
  386.             snode = self
  387.         elif snode.ownerDocument is not self:
  388.             raise xml.dom.WrongDocumentErr()
  389.         return snode.toxml()
  390.  
  391.  
  392.  
  393. class DOMImplementationLS:
  394.     MODE_SYNCHRONOUS = 1
  395.     MODE_ASYNCHRONOUS = 2
  396.     
  397.     def createDOMBuilder(self, mode, schemaType):
  398.         if schemaType is not None:
  399.             raise xml.dom.NotSupportedErr('schemaType not yet supported')
  400.         if mode == self.MODE_SYNCHRONOUS:
  401.             return DOMBuilder()
  402.         if None == self.MODE_ASYNCHRONOUS:
  403.             raise xml.dom.NotSupportedErr('asynchronous builders are not supported')
  404.         raise ValueError('unknown value for mode')
  405.  
  406.     
  407.     def createDOMWriter(self):
  408.         raise NotImplementedError("the writer interface hasn't been written yet!")
  409.  
  410.     
  411.     def createDOMInputSource(self):
  412.         return DOMInputSource()
  413.  
  414.  
  415.